package com.gwt.boot.tools;

import cn.hutool.extra.spring.SpringUtil;
import com.alibaba.fastjson.JSONObject;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @author by zhangbr
 * @date 2020/4/20.
 */
public class RedisTools {
    @SuppressWarnings("unchecked")
    private static RedisTemplate<String, Object> redisTemplate = SpringUtil.getBean("redisTemplate", RedisTemplate.class);

    public RedisTools(RedisTemplate<String, Object> redisTemplate) {
        RedisTools.redisTemplate = redisTemplate;
    }
    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public static Object get(String key){
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }
    public static <T> T hGetObject(String key,  Class<T> clazz){
        Object o = redisTemplate.opsForValue().get(key);
        return JSONObject.parseObject((String) o, clazz);
    }

    public static <T> T hGetObject(String key, String item, Class<T> clazz){
        Object o = redisTemplate.opsForHash().get(key, item);
        return JSONObject.parseObject((String) o, clazz);
    }

    public static <T> List<T> hGetList(String key, String item, Class<T> clazz){
        Object o = redisTemplate.opsForHash().get(key, item);
        return JSONObject.parseArray((String) o, clazz);
    }

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public static boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            return false;
        }
    }


    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @return true 成功 false失败
     */
    public static boolean hSet(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    public static boolean hSet(String key, Object value, Long time, TimeUnit unit) {
        try {
            redisTemplate.opsForValue().set(key, value);
            if (time > 0) {
                expire(key, time,unit);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    public static boolean hSet(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    private static boolean expire(String key, long time,TimeUnit unit){
        try {
            if(time>0){
                redisTemplate.expire(key, time, unit);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public static void hDel(String key, Object... item){
        redisTemplate.opsForHash().delete(key,item);
    }
    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     */
    public static void hDel(String key){
        redisTemplate.delete(key);
    }

    /**
     * redis自增命令
     * @param key 如果key有值加1，否则新增key且初始化为1
     */
    public static Long increment(String key){
        try {
            return redisTemplate.opsForValue().increment(key);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * redis自增命令
     * @param key 如果key有值加1，否则新增key且初始化为1
     * @param delta 增长量
     */
    public static Long increment(String key, Long delta){
        Long num = null;
        try {
            num = null == delta ? num : redisTemplate.opsForValue().increment(key, delta);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return num;
    }

    /**
     * redis自增命令
     * @param key 如果key有值加1，否则新增key且初始化为1
     * @param time 时间
     * @param unit 时间类型
     */
    public static Long increment(String key, Long time, TimeUnit unit){
        Long num = null;
        try {
            num = increment(key);
            if (null != time && time > 0) {
                expire(key, time, unit);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return num;
    }

    /**
     * redis自增命令
     * @param key 如果key有值加1，否则新增key且初始化为1
     * @param delta 增长量
     * @param time 时间
     * @param unit 时间类型
     */
    public static Long increment(String key, Long delta, Long time, TimeUnit unit){
        Long num = null;
        try {
            num = increment(key, delta);
            if (null != time && time > 0) {
                expire(key, time, unit);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return num;
    }

    /**
     * redis SETNX命令，
     * 如果key有返回false，若无返回true
     * 若不设置time，默认为30分钟
     */
    public  static boolean setIfAbsent(String key, Object value, Long time, TimeUnit unit){
        if(null == time || time <= 0){
            time = 30L;
            unit = TimeUnit.MINUTES;
        }
        try {
            return redisTemplate.opsForValue().setIfAbsent(key, value, time, unit);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

}